home *** CD-ROM | disk | FTP | other *** search
/ SPACE 2 / SPACE - Library 2 - Volume 1.iso / program / 515 / rcs5ap1s.lzh / RCSSYN.C < prev    next >
C/C++ Source or Header  |  1991-01-30  |  19KB  |  770 lines
  1. /*
  2.  *                     RCS file input
  3.  */
  4. /*********************************************************************************
  5.  *                       Syntax Analysis.
  6.  *                       Keyword table
  7.  *                       Testprogram: define SYNTEST
  8.  *                       Compatibility with Release 2: define COMPAT2=1
  9.  *********************************************************************************
  10.  */
  11.  
  12. /* Copyright (C) 1982, 1988, 1989 Walter Tichy
  13.    Copyright 1990 by Paul Eggert
  14.    Distributed under license by the Free Software Foundation, Inc.
  15.  
  16. This file is part of RCS.
  17.  
  18. RCS is free software; you can redistribute it and/or modify
  19. it under the terms of the GNU General Public License as published by
  20. the Free Software Foundation; either version 1, or (at your option)
  21. any later version.
  22.  
  23. RCS is distributed in the hope that it will be useful,
  24. but WITHOUT ANY WARRANTY; without even the implied warranty of
  25. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26. GNU General Public License for more details.
  27.  
  28. You should have received a copy of the GNU General Public License
  29. along with RCS; see the file COPYING.  If not, write to
  30. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  31.  
  32. Report problems and direct all questions to:
  33.  
  34.     rcs-bugs@cs.purdue.edu
  35.  
  36. */
  37.  
  38.  
  39. /* $Log: rcssyn.c,v $
  40.  * Revision 5.5  1991/01/30  14:21:32  apratt
  41.  * CI with RCS version 5
  42.  *
  43.  * Revision 5.4  90/11/01  05:28:48  eggert
  44.  * checked in with -k by apratt at 91.01.10.13.15.30.
  45.  * 
  46.  * Revision 5.4  1990/11/01  05:28:48  eggert
  47.  * When ignoring unknown phrases, copy them to the output RCS file.
  48.  * Permit arbitrary data in logs and comment leaders.
  49.  * Don't check for nontext on initial checkin.
  50.  *
  51.  * Revision 5.3  1990/09/20  07:58:32  eggert
  52.  * Remove the test for non-text bytes; it caused more pain than it cured.
  53.  *
  54.  * Revision 5.2  1990/09/04  08:02:30  eggert
  55.  * Parse RCS files with no revisions.
  56.  * Don't strip leading white space from diff commands.  Count RCS lines better.
  57.  *
  58.  * Revision 5.1  1990/08/29  07:14:06  eggert
  59.  * Add -kkvl.  Clean old log messages too.
  60.  *
  61.  * Revision 5.0  1990/08/22  08:13:44  eggert
  62.  * Try to parse future RCS formats without barfing.
  63.  * Add -k.  Don't require final newline.
  64.  * Remove compile-time limits; use malloc instead.
  65.  * Don't output branch keyword if there's no default branch,
  66.  * because RCS version 3 doesn't understand it.
  67.  * Tune.  Remove lint.
  68.  * Add support for ISO 8859.  Ansify and Posixate.
  69.  * Check that a newly checked-in file is acceptable as input to 'diff'.
  70.  * Check diff's output.
  71.  *
  72.  * Revision 4.6  89/05/01  15:13:32  narten
  73.  * changed copyright header to reflect current distribution rules
  74.  * 
  75.  * Revision 4.5  88/08/09  19:13:21  eggert
  76.  * Allow cc -R; remove lint.
  77.  * 
  78.  * Revision 4.4  87/12/18  11:46:16  narten
  79.  * more lint cleanups (Guy Harris)
  80.  * 
  81.  * Revision 4.3  87/10/18  10:39:36  narten
  82.  * Updating version numbers. Changes relative to 1.1 actually relative to
  83.  * 4.1
  84.  * 
  85.  * Revision 1.3  87/09/24  14:00:49  narten
  86.  * Sources now pass through lint (if you ignore printf/sprintf/fprintf 
  87.  * warnings)
  88.  * 
  89.  * Revision 1.2  87/03/27  14:22:40  jenkins
  90.  * Port to suns
  91.  * 
  92.  * Revision 4.1  83/03/28  11:38:49  wft
  93.  * Added parsing and printing of default branch.
  94.  * 
  95.  * Revision 3.6  83/01/15  17:46:50  wft
  96.  * Changed readdelta() to initialize selector and log-pointer.
  97.  * Changed puttree to check for selector==DELETE; putdtext() uses DELNUMFORM.
  98.  *
  99.  * Revision 3.5  82/12/08  21:58:58  wft
  100.  * renamed Commentleader to Commleader.
  101.  *
  102.  * Revision 3.4  82/12/04  13:24:40  wft
  103.  * Added routine gettree(), which updates keeplock after reading the
  104.  * delta tree.
  105.  *
  106.  * Revision 3.3  82/11/28  21:30:11  wft
  107.  * Reading and printing of Suffix removed; version COMPAT2 skips the
  108.  * Suffix for files of release 2 format. Fixed problems with printing nil.
  109.  *
  110.  * Revision 3.2  82/10/18  21:18:25  wft
  111.  * renamed putdeltatext to putdtext.
  112.  *
  113.  * Revision 3.1  82/10/11  19:45:11  wft
  114.  * made sure getc() returns into an integer.
  115.  */
  116.  
  117.  
  118.  
  119. /* version COMPAT2 reads files of the format of release 2 and 3, but
  120.  * generates files of release 3 format. Need not be defined if no
  121.  * old RCS files generated with release 2 exist.
  122.  */
  123. /* version SYNTEST inputs a RCS file and then prints out its internal
  124.  * data structures.
  125. */
  126.  
  127. #include "rcsbase.h"
  128.  
  129. libId(synId, "$Id: rcssyn.c,v 5.5 1991/01/30 14:21:32 apratt Exp $")
  130.  
  131. /* forward */
  132. static const char *getkeyval P((const char*,enum tokens,int));
  133.  
  134. /* keyword table */
  135.  
  136. const char
  137.     Kdesc[]     = "desc",
  138.     Klog[]      = "log",
  139.     Ktext[]     = "text";
  140.  
  141. static const char
  142.     Kaccess[]   = "access",
  143.     Kauthor[]   = "author",
  144.     Kbranch[]   = "branch",
  145.     Kbranches[] = "branches",
  146.     Kcomment[]  = "comment",
  147.     Kdate[]     = "date",
  148.     Kexpand[]   = "expand",
  149.     Khead[]     = "head",
  150.     Klocks[]    = "locks",
  151.     Knext[]     = "next",
  152.     Kstate[]    = "state",
  153.     Kstrict[]   = "strict",
  154. #if COMPAT2
  155.     Ksuffix[]   = "suffix",
  156. #endif
  157.     Ksymbols[]  = "symbols";
  158.  
  159. static struct buf Commleader;
  160. static struct cbuf Ignored;
  161. struct cbuf Comment;
  162. struct access   * AccessList;
  163. struct assoc    * Symbols;
  164. struct lock     * Locks;
  165. int          Expand;
  166. int               StrictLocks;
  167. struct hshentry * Head;
  168. const char      * Dbranch;
  169. int               TotalDeltas;
  170.  
  171.  
  172.     static void
  173. getsemi(key)
  174.     const char *key;
  175. /* Get a semicolon to finish off a phrase started by KEY.  */
  176. {
  177.     if (!getlex(SEMI))
  178.         fatserror("missing ';' after '%s'", key);
  179. }
  180.  
  181.     static struct hshentry *
  182. getdnum()
  183. /* Get a delta number.  */
  184. {
  185.     register struct hshentry *delta = getnum();
  186.     if (delta && countnumflds(delta->num)&1)
  187.         fatserror("%s isn't a delta number", delta->num);
  188.     return delta;
  189. }
  190.  
  191.  
  192.     void
  193. getadmin()
  194. /* Read an <admin> and initialize the appropriate global variables.  */
  195. {
  196.     register const char *id;
  197.         struct access   * newaccess;
  198.         struct assoc    * newassoc;
  199.         struct lock     * newlock;
  200.         struct hshentry * delta;
  201.     struct access **LastAccess;
  202.     struct assoc **LastSymbol;
  203.     struct lock **LastLock;
  204.     struct buf b;
  205.     struct cbuf cb;
  206.  
  207.         TotalDeltas=0;
  208.  
  209.     getkey(Khead);
  210.     Head = getdnum();
  211.     getsemi(Khead);
  212.  
  213.     Dbranch = nil;
  214.     if (getkeyopt(Kbranch)) {
  215.         if ((delta = getnum()))
  216.             Dbranch = delta->num;
  217.         getsemi(Kbranch);
  218.         }
  219.  
  220.  
  221. #if COMPAT2
  222.         /* read suffix. Only in release 2 format */
  223.     if (getkeyopt(Ksuffix)) {
  224.                 if (nexttok==STRING) {
  225.             readstring(); nextlex(); /* Throw away the suffix.  */
  226.         } else if (nexttok==ID) {
  227.                         nextlex();
  228.                 }
  229.         getsemi(Ksuffix);
  230.         }
  231. #endif
  232.  
  233.     getkey(Kaccess);
  234.     LastAccess = &AccessList;
  235.         while (id=getid()) {
  236.         newaccess = ftalloc(struct access);
  237.                 newaccess->login = id;
  238.         *LastAccess = newaccess;
  239.         LastAccess = &newaccess->nextaccess;
  240.         }
  241.     *LastAccess = nil;
  242.     getsemi(Kaccess);
  243.  
  244.     getkey(Ksymbols);
  245.     LastSymbol = &Symbols;
  246.         while (id = getid()) {
  247.                 if (!getlex(COLON))
  248.             fatserror("missing ':' in symbolic name definition");
  249.                 if (!(delta=getnum())) {
  250.             fatserror("missing number in symbolic name definition");
  251.                 } else { /*add new pair to association list*/
  252.             newassoc = ftalloc(struct assoc);
  253.                         newassoc->symbol=id;
  254.             newassoc->num = delta->num;
  255.             *LastSymbol = newassoc;
  256.             LastSymbol = &newassoc->nextassoc;
  257.                 }
  258.         }
  259.     *LastSymbol = nil;
  260.     getsemi(Ksymbols);
  261.  
  262.     getkey(Klocks);
  263.     LastLock = &Locks;
  264.         while (id = getid()) {
  265.                 if (!getlex(COLON))
  266.             fatserror("missing ':' in lock");
  267.         if (!(delta=getdnum())) {
  268.             fatserror("missing number in lock");
  269.                 } else { /*add new pair to lock list*/
  270.             newlock = ftalloc(struct lock);
  271.                         newlock->login=id;
  272.                         newlock->delta=delta;
  273.             *LastLock = newlock;
  274.             LastLock = &newlock->nextlock;
  275.                 }
  276.         }
  277.     *LastLock = nil;
  278.     getsemi(Klocks);
  279.  
  280.     if ((StrictLocks = getkeyopt(Kstrict)))
  281.         getsemi(Kstrict);
  282.  
  283.     Comment.size = 0;
  284.     if (getkeyopt(Kcomment)) {
  285.         if (nexttok==STRING) {
  286.             Comment = savestring(&Commleader);
  287.             nextlex();
  288.         }
  289.         getsemi(Kcomment);
  290.         }
  291.  
  292.     Expand = KEYVAL_EXPAND;
  293.     if (getkeyopt(Kexpand)) {
  294.         if (nexttok==STRING) {
  295.             bufautobegin(&b);
  296.             cb = savestring(&b);
  297.             if ((Expand = str2expmode(cb.string)) < 0)
  298.                 fatserror("unknown expand mode %s", b.string);
  299.             bufautoend(&b);
  300.             nextlex();
  301.         }
  302.         getsemi(Kexpand);
  303.         }
  304.     Ignored = getphrases(Kdesc);
  305. }
  306.  
  307. const char *const expand_names[] = {
  308.     /* These must agree with *_EXPAND in rcsbase.h.  */
  309.     "kv","kvl","k","v","o",
  310.     0
  311. };
  312.  
  313.     int
  314. str2expmode(s)
  315.     const char *s;
  316. /* Yield expand mode corresponding to S, or -1 if bad.  */
  317. {
  318.     const char *const *p;
  319.  
  320.     for (p = expand_names;  *p;  ++p)
  321.         if (strcmp(*p,s) == 0)
  322.             return p - expand_names;
  323.     return -1;
  324. }
  325.  
  326.  
  327.     void
  328. ignorephrase()
  329. /* Ignore a phrase introduced by a later version of RCS.  */
  330. {
  331.     warnignore();
  332.     hshenter=false;
  333.     for (;;) {
  334.         switch (nexttok) {
  335.         case SEMI: hshenter=true; nextlex(); return;
  336.         case ID:
  337.         case NUM: ffree1(NextString); break;
  338.         case STRING: readstring(); break;
  339.         default: break;
  340.         }
  341.         nextlex();
  342.     }
  343. }
  344.  
  345.  
  346.     static int
  347. getdelta()
  348. /* Function: reads a delta block.
  349.  * returns false if the current block does not start with a number.
  350.  */
  351. {
  352.         register struct hshentry * Delta, * num;
  353.     struct branchhead **LastBranch, *NewBranch;
  354.  
  355.     if (!(Delta = getdnum()))
  356.         return false;
  357.  
  358.         hshenter = false; /*Don't enter dates into hashtable*/
  359.         Delta->date = getkeyval(Kdate, NUM, false);
  360.         hshenter=true;    /*reset hshenter for revision numbers.*/
  361.  
  362.         Delta->author = getkeyval(Kauthor, ID, false);
  363.  
  364.         Delta->state = getkeyval(Kstate, ID, true);
  365.  
  366.     getkey(Kbranches);
  367.     LastBranch = &Delta->branches;
  368.     while ((num = getdnum())) {
  369.         NewBranch = ftalloc(struct branchhead);
  370.                 NewBranch->hsh = num;
  371.         *LastBranch = NewBranch;
  372.         LastBranch = &NewBranch->nextbranch;
  373.         }
  374.     *LastBranch = nil;
  375.     getsemi(Kbranches);
  376.  
  377.     getkey(Knext);
  378.     Delta->next = num = getdnum();
  379.     getsemi(Knext);
  380.     Delta->lockedby = nil;
  381.     Delta->selector = true;
  382.     Delta->ig = getphrases(Kdesc);
  383.         TotalDeltas++;
  384.         return (true);
  385. }
  386.  
  387.  
  388.     void
  389. gettree()
  390. /* Function: Reads in the delta tree with getdelta(), then
  391.  * updates the lockedby fields.
  392.  */
  393. {
  394.     const struct lock *currlock;
  395.  
  396.         while (getdelta());
  397.         currlock=Locks;
  398.         while (currlock) {
  399.                 currlock->delta->lockedby = currlock->login;
  400.                 currlock = currlock->nextlock;
  401.         }
  402. }
  403.  
  404.  
  405.     void
  406. getdesc(prdesc)
  407. int  prdesc;
  408. /* Function: read in descriptive text
  409.  * nexttok is not advanced afterwards.
  410.  * If prdesc is set, the text is printed to stdout.
  411.  */
  412. {
  413.  
  414.     getkeystring(Kdesc);
  415.         if (prdesc)
  416.                 printstring();  /*echo string*/
  417.         else    readstring();   /*skip string*/
  418. }
  419.  
  420.  
  421.  
  422.  
  423.  
  424.  
  425.     static const char *
  426. getkeyval(keyword, token, optional)
  427.     const char *keyword;
  428.     enum tokens token;
  429.     int optional;
  430. /* reads a pair of the form
  431.  * <keyword> <token> ;
  432.  * where token is one of <id> or <num>. optional indicates whether
  433.  * <token> is optional. A pointer to
  434.  * the actual character string of <id> or <num> is returned.
  435.  */
  436. {
  437.     register const char *val = nil;
  438.  
  439.     getkey(keyword);
  440.         if (nexttok==token) {
  441.                 val = NextString;
  442.                 nextlex();
  443.         } else {
  444.         if (!optional)
  445.             fatserror("missing %s", keyword);
  446.         }
  447.     getsemi(keyword);
  448.         return(val);
  449. }
  450.  
  451.  
  452.  
  453.  
  454.     void
  455. putadmin(fout)
  456. register FILE * fout;
  457. /* Function: Print the <admin> node read with getadmin() to file fout.
  458.  * Assumption: Variables AccessList, Symbols, Locks, StrictLocks,
  459.  * and Head have been set.
  460.  */
  461. {
  462.     const struct assoc *curassoc;
  463.     const struct lock *curlock;
  464.     const struct access *curaccess;
  465.     register const char *sp;
  466.     register size_t ss;
  467.  
  468.     aprintf(fout, "%s\t%s;\n", Khead, Head?Head->num:"");
  469.     if (Dbranch && VERSION(4)<=RCSversion)
  470.         aprintf(fout, "%s\t%s;\n", Kbranch, Dbranch);
  471.  
  472.     aputs(Kaccess, fout);
  473.         curaccess = AccessList;
  474.         while (curaccess) {
  475.            aprintf(fout, "\n\t%s", curaccess->login);
  476.                curaccess = curaccess->nextaccess;
  477.         }
  478.     aprintf(fout, ";\n%s", Ksymbols);
  479.         curassoc = Symbols;
  480.         while (curassoc) {
  481.            aprintf(fout, "\n\t%s:%s", curassoc->symbol, curassoc->num);
  482.                curassoc = curassoc->nextassoc;
  483.         }
  484.     aprintf(fout, ";\n%s", Klocks);
  485.         curlock = Locks;
  486.         while (curlock) {
  487.            aprintf(fout, "\n\t%s:%s", curlock->login, curlock->delta->num);
  488.                curlock = curlock->nextlock;
  489.         }
  490.     if (StrictLocks) aprintf(fout, "; %s", Kstrict);
  491.     aprintf(fout, ";\n");
  492.     if ((ss = Comment.size)) {
  493.         aprintf(fout, "%s\t%c", Kcomment, SDELIM);
  494.         sp = Comment.string;
  495.         do {
  496.             if (*sp == SDELIM)
  497.             afputc(SDELIM,fout);
  498.             afputc(*sp++,fout);
  499.         } while (--ss);
  500.         aprintf(fout, "%c;\n", SDELIM);
  501.         }
  502.     if (Expand != KEYVAL_EXPAND)
  503.         aprintf(fout, "%s\t%c%s%c;\n",
  504.             Kexpand, SDELIM, expand_names[Expand], SDELIM
  505.         );
  506.     awrite(Ignored.string, Ignored.size, fout);
  507.     aputc('\n', fout);
  508. }
  509.  
  510.  
  511.  
  512.  
  513.     static void
  514. putdelta(node,fout)
  515. register const struct hshentry *node;
  516. register FILE * fout;
  517. /* Function: prints a <delta> node to fout;
  518.  */
  519. {
  520.     const struct branchhead *nextbranch;
  521.  
  522.         if (node == nil) return;
  523.  
  524.     aprintf(fout, "\n%s\n%s\t%s;\t%s %s;\t%s %s;\nbranches",
  525.         node->num,
  526.         Kdate, node->date,
  527.         Kauthor, node->author,
  528.         Kstate, node->state?node->state:""
  529.     );
  530.         nextbranch = node->branches;
  531.         while (nextbranch) {
  532.            aprintf(fout, "\n\t%s", nextbranch->hsh->num);
  533.                nextbranch = nextbranch->nextbranch;
  534.         }
  535.  
  536.     aprintf(fout, ";\n%s\t%s;\n", Knext, node->next?node->next->num:"");
  537.     awrite(node->ig.string, node->ig.size, fout);
  538. }
  539.  
  540.  
  541.  
  542.  
  543.     void
  544. puttree(root,fout)
  545. const struct hshentry * root;
  546. register FILE * fout;
  547. /* Function: prints the delta tree in preorder to fout, starting with root.
  548.  */
  549. {
  550.     const struct branchhead *nextbranch;
  551.  
  552.         if (root==nil) return;
  553.  
  554.     if (root->selector)
  555.         putdelta(root,fout);
  556.  
  557.         puttree(root->next,fout);
  558.  
  559.         nextbranch = root->branches;
  560.         while (nextbranch) {
  561.              puttree(nextbranch->hsh,fout);
  562.              nextbranch = nextbranch->nextbranch;
  563.         }
  564. }
  565.  
  566.  
  567.  
  568. int putdtext(num,log,srcfilename,fout,diffmt)
  569.     const char *num, *srcfilename;
  570.     struct cbuf log;
  571.     FILE *fout;
  572.     int diffmt;
  573. /* Function: write a deltatext-node to fout.
  574.  * num points to the deltanumber, log to the logmessage, and
  575.  * sourcefile contains the text. Doubles up all SDELIMs in both the
  576.  * log and the text; Makes sure the log message ends in \n.
  577.  * returns false on error.
  578.  * If diffmt is true, also checks that text is valid diff -n output.
  579.  */
  580. {
  581.     FILE *fin;
  582.     int result;
  583.     if (!(fin = fopen(srcfilename,"r"))) {
  584.         eerror(srcfilename);
  585.         return false;
  586.     }
  587.     result = putdftext(num,log,fin,fout,diffmt);
  588.     ffclose(fin);
  589.     return result;
  590. }
  591.  
  592.     int
  593. putdftext(num,log,fin,fout,diffmt)
  594.     const char *num;
  595.     struct cbuf log;
  596.     register FILE *fin;
  597.     register FILE *fout;
  598.     int diffmt;
  599. /* like putdtext(), except the source file is already open */
  600. {
  601.     register const char *sp;
  602.     register int c;
  603.     register size_t ss;
  604.     int ed;
  605.     struct diffcmd dc;
  606.  
  607.     aprintf(fout,DELNUMFORM,num,Klog);
  608.         /* put log */
  609.     afputc(SDELIM,fout);
  610.     sp = log.string;
  611.     for (ss = log.size;  ss;  --ss) {
  612.         if (*sp == SDELIM)
  613.             aputc(SDELIM,fout);
  614.         aputc(*sp++,fout);
  615.     }
  616.         /* put text */
  617.     aprintf(fout, "\n%c\n%s\n%c",SDELIM,Ktext,SDELIM);
  618.     if (!diffmt) {
  619.         /* Copy the file */
  620.         while ((c=getc(fin))!=EOF) {
  621.         if (c==SDELIM) aputc(SDELIM,fout);   /*double up SDELIM*/
  622.         aputc(c,fout);
  623.         }
  624.     } else {
  625.         initdiffcmd(&dc);
  626.         while (0  <=  (ed = getdiffcmd(fin,EOF,fout,&dc)))
  627.         if (ed)
  628.             while (dc.nlines--)
  629.             do {
  630.                 if ((c=getc(fin)) == EOF) {
  631.                 if (!dc.nlines)
  632.                     goto OK_EOF;
  633.                 faterror("unexpected EOF in diff output");
  634.                 }
  635.                 if (c==SDELIM) aputc(SDELIM,fout);
  636.                 aputc(c,fout);
  637.             } while (c != '\n');
  638.     }
  639.     OK_EOF:
  640.     aprintf(fout, "%c\n", SDELIM);
  641.     return true;
  642. }
  643.  
  644.     void
  645. initdiffcmd(dc)
  646.     register struct diffcmd *dc;
  647. /* Initialize *dc suitably for getdiffcmd(). */
  648. {
  649.     dc->adprev = 0;
  650.     dc->dafter = 0;
  651. }
  652.  
  653.     int
  654. getdiffcmd(fin,delimiter,fout,dc)
  655.     register FILE *fin, *fout;
  656.     int delimiter;
  657.     struct diffcmd *dc;
  658. /* Get a editing command output by 'diff -n' from fin.
  659.  * The input is delimited by the delimiter, which may be EOF for no delimiter.
  660.  * Copy a clean version of the command to fout (if nonnull).
  661.  * Yield 0 for 'd', 1 for 'a', and -1 for EOF.
  662.  * Store the command's line number and length into dc->line1 and dc->nlines.
  663.  * Keep dc->adprev and dc->dafter up to date.
  664.  */
  665. {
  666.     register int c;
  667.     register char *p;
  668.     unsigned long line1, nlines;
  669.     char buf[BUFSIZ];
  670.     c = getc(fin);
  671.     if (c==delimiter) {
  672.         if (c!=EOF && fout)
  673.             aputc(c, fout);
  674.         return EOF;
  675.     }
  676.     p = buf;
  677.     do {
  678.         if (c == EOF) {
  679.             faterror("unexpected EOF in diff output");
  680.         }
  681.         if (buf+BUFSIZ-2 <= p) {
  682.             faterror("diff output command line too long");
  683.         }
  684.         *p++ = c;
  685.     } while ((c=getc(fin)) != '\n');
  686.     if (delimiter!=EOF)
  687.         ++rcsline;
  688.     *p = '\0';
  689.     for (p = buf+1;  *p++ == ' ';)
  690.         ;
  691.     --p;
  692.     if (!((buf[0]=='a' || buf[0]=='d')  &&  isdigit(*p))) {
  693.         faterror("bad diff output: %s", buf);
  694.     }
  695.     line1 = 0;
  696.     do {
  697.         line1 = line1*10 + (*p++ - '0');
  698.     } while (isdigit(*p));
  699.     while (*p++ == ' ')
  700.         ;
  701.     --p;
  702.     nlines = 0;
  703.     while (isdigit(*p))
  704.         nlines = nlines*10 + (*p++ - '0');
  705.     if (!nlines) {
  706.         faterror("incorrect range %lu in diff output: %s", nlines, buf);
  707.     }
  708.     switch (buf[0]) {
  709.         case 'a':
  710.         if (line1 < dc->adprev) {
  711.             faterror("backward insertion in diff output: %s", buf);
  712.         }
  713.         dc->adprev = line1 + 1;
  714.         break;
  715.         case 'd':
  716.         if (line1 < dc->adprev  ||  line1 < dc->dafter) {
  717.             faterror("backward deletion in diff output: %s", buf);
  718.         }
  719.         dc->adprev = line1;
  720.         dc->dafter = line1 + nlines;
  721.         break;
  722.     }
  723.     if (fout) {
  724.         aprintf(fout, "%s\n", buf);
  725.     }
  726.     dc->line1 = line1;
  727.     dc->nlines = nlines;
  728.     return buf[0] == 'a';
  729. }
  730.  
  731.  
  732.  
  733. #ifdef SYNTEST
  734.  
  735. const char cmdid[] = "syntest";
  736.  
  737.     int
  738. main(argc,argv)
  739. int argc; char * argv[];
  740. {
  741.  
  742.         if (argc<2) {
  743.         aputs("No input file\n",stderr);
  744.         exitmain(EXIT_FAILURE);
  745.         }
  746.         if ((finptr=fopen(argv[1], "r")) == NULL) {
  747.         faterror("can't open input file %s", argv[1]);
  748.         }
  749.         Lexinit();
  750.         getadmin();
  751.         putadmin(stdout);
  752.  
  753.         gettree();
  754.         puttree(Head,stdout);
  755.  
  756.         getdesc(true);
  757.  
  758.         if (nextlex(),nexttok!=EOFILE) {
  759.         fatserror("expecting EOF");
  760.         }
  761.     exitmain(EXIT_SUCCESS);
  762. }
  763.  
  764.  
  765. exiting void exiterr() { _exit(EXIT_FAILURE); }
  766.  
  767.  
  768. #endif
  769.  
  770.